package com.test.jdk8.demo2;

import java.util.Comparator;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @ClassName Lambda5
 * @Description 访问接口的默认方法
 * @Author 维康
 * @Date 2018/7/10 10:47
 * @Version 1.0
 **/
public class Lambda5 {

    public static void main(String[] args) {
        Predicate<String> predicate = (s) -> s.length() > 0;
        // true
        System.out.println(predicate.test("foo"));
        // false
        System.out.println(predicate.negate().test("foo"));
        Predicate<Boolean> nonNull = Objects::nonNull;
        Predicate<Boolean> isNull = Objects::isNull;
        Predicate<String> isEmpty = String::isEmpty;
        Predicate<String> isNotEmpty = isEmpty.negate();
        System.out.println(nonNull.test(null));
        System.out.println(isNull.test(null));
        System.out.println(isEmpty.test("sss"));
        System.out.println(isNotEmpty.test(""));


        /**
         * Function 接口
         Function 接口有一个参数并且返回一个结果，并附带了一些可以和其他函数组合的默认方法（compose, andThen
         */
        Function<String, Integer> toInteger = Integer::valueOf;
        System.out.println(toInteger.apply("123").getClass());
        Function<String, Object> toInteger2 = toInteger.andThen(String::valueOf);
        System.out.println(toInteger2.apply("123").getClass());


        /**
         * Supplier 接口
         * Supplier 接口返回一个任意范型的值，和Function接口不同的是该接口没有任何参数
         */

        // new Person
        Supplier<Person> personSupplier = Person::new;
        personSupplier.get();

        /*
            Consumer 接口
            Consumer 接口表示执行在单个参数上的操作。接口只有一个参数，且无返回值
        */
        Supplier<LambdaClassTest> personSupplier2 = LambdaClassTest::new;
        Consumer<LambdaClassTest> greeter = (lt) -> System.out.println("Hello, " + lt.getTest());
        greeter.accept(personSupplier2.get());


      /*
        Comparator 接口
        Comparator 是老Java中的经典接口， Java 8在此之上添加了多种默认方法：
        */

        Comparator<Person> comparator = (p1, p2) -> p1.getXing().compareTo(p2.getXing());
        Person p1 = new Person("John", "Doe");
        Person p2 = new Person("Alice", "Wonderland");
        // > 0
        comparator.compare(p1, p2);
        // < 0
        comparator.reversed().compare(p1, p2);



      /*  Optional 接口
        Optional 不是函数是接口，这是个用来防止NullPointerException异常的辅助类型，
        这是下一届中将要用到的重要概念，现在先简单的看看这个接口能干什么：
        Optional 被定义为一个简单的容器，其值可能是null或者不是null。
        在Java 8之前一般某个函数应该返回非空对象但是偶尔却可能返回了null，而在Java 8中，
        不推荐你返回null而是返回Optional。
        */
        Optional<String> optional = Optional.of("bam");
        optional.isPresent();           // true
        optional.get();                 // "bam"
        optional.orElse("fallback");    // "bam"
        optional.ifPresent((s) -> System.out.println(s.charAt(0)));     // "b"
    }

}

class Person{

    private String xing;
    private String ming;

    @Override
    public String toString() {
        return "Person{" +
                "xing='" + xing + '\'' +
                ", ming='" + ming + '\'' +
                '}';
    }

    public Person() {
    }

    public Person(String xing, String ming) {
        this.xing = xing;
        this.ming = ming;
    }

    public String getXing() {
        return xing;
    }

    public void setXing(String xing) {
        this.xing = xing;
    }

    public String getMing() {
        return ming;
    }

    public void setMing(String ming) {
        this.ming = ming;
    }
}

class LambdaClassTest{

    private String test = "world";

    void print(String it){

    }
    public String getTest() {
        return test;
    }

    public void setTest(String test) {
        this.test = test;
    }
}